package com.wtb.javatool.service.impl;

import com.wtb.javatool.common.PageBean;
import com.wtb.javatool.dao.CourseMapper;
import com.wtb.javatool.dto.CourseDto;
import com.wtb.javatool.entity.Course;
import com.wtb.javatool.service.CourseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class CourseServiceImpl implements CourseService {

    private final CourseMapper courseMapper;

    @Autowired
    public CourseServiceImpl(CourseMapper courseMapper) {
        this.courseMapper = courseMapper;
    }

    /**
     * 查询跟教师用户相关的所有课程
     *
     * @param userId 用户id
     * @param courseName 课程名称（可选，用于过滤）
     * @param currentPage   当前页数
     * @param pageSize      每页大小
     * @return 课程信息与关联的项目和教师用户
     */
    public PageBean<CourseDto> findCoursesByUserId(Long userId, String courseName, Integer currentPage, Integer pageSize) {
        if (currentPage == null || currentPage < 0) {
            currentPage = 0;
        }
        if (pageSize == null || pageSize <= 0) {
            pageSize = 10;
        }
        
        // 计算偏移量
        int offset = currentPage * pageSize;
        
        // 查询课程数据
        List<CourseDto> courseDtos = courseMapper.findCoursesByUserId(userId, courseName, offset, pageSize);
        Integer count = courseMapper.findCoursesByUserIdCount(userId, courseName);
        
        // 设置分页结果
        PageBean<CourseDto> pageBean = new PageBean<>();
        pageBean.setRows(courseDtos);
        pageBean.setTotalCount(count);

        return pageBean;
    }

    /**
     * 根据课程ID、课程名称查询课程。
     * 如果提供了课程ID，则根据课程ID查找用户并返回单个课程的列表（或空列表如果未找到）。
     * 如果未提供课程ID但提供了课程名称，则根据课程名称查找课程并返回匹配的课程列表（或空列表如果未找到）。
     * 如果没有提供任何参数，则返回所有课程列表。
     *
     * @param courseId   课程ID。
     * @param courseName 课程名。
     * @return 查找到的课程列表，如果未找到则返回空列表。
     */
    public List<Course> findCourse(Long courseId, String courseName) {
        List<Course> courses;
        if (courseId != null) {
            courses = courseMapper.findCourseByCourseId(courseId);
            return courses;
        } else if (courseName != null && !courseName.trim().isEmpty()) {
            courses = courseMapper.findCourseByCourseName(courseName);
            return courses;
        } else {
            // 如果没有提供任何参数，返回所有课程
            courses = courseMapper.findAllCourses();
            return courses;
        }
    }

    /**
     * 获取所有课程列表
     * @return 所有课程列表
     */
    @Override
    public List<Course> findAllCourses() {
        return courseMapper.findAllCourses();
    }
    
    /**
     * 创建新课程
     * 
     * @param course 课程信息
     * @param userId 创建者用户ID
     * @param projectIds 关联的项目ID列表
     * @return 创建的课程ID
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public Long createCourse(Course course, Long userId, List<Long> projectIds) {
        if (course == null) {
            throw new IllegalArgumentException("课程信息不能为空");
        }
        
        if (userId == null) {
            throw new IllegalArgumentException("创建者ID不能为空");
        }
        
        // 设置创建者ID
        course.setCreatorId(userId);
        // 设置为项目式教学课程
        course.setProjectTeaching(1);
        // 设置默认课程状态为未开课
        course.setCourseStatus(0);
        
        // 确保课程名称不为空
        if (course.getCourseName() == null || course.getCourseName().trim().isEmpty()) {
            throw new IllegalArgumentException("课程名称不能为空");
        }
        
        // 如果课程描述为空，设置默认值
        if (course.getCourseDescription() == null || course.getCourseDescription().trim().isEmpty()) {
            course.setCourseDescription("项目式教学课程");
        }
        
        // 插入课程
        try {
            courseMapper.insertCourse(course);
        } catch (Exception e) {
            throw new RuntimeException("创建课程失败: " + e.getMessage(), e);
        }
        
        Long courseId = course.getCourseId();
        if (courseId == null) {
            throw new RuntimeException("创建课程失败: 无法获取课程ID");
        }
        
        // 添加课程与教师关联关系
        try {
            courseMapper.insertCourseTeacherRef(courseId, userId);
        } catch (Exception e) {
            throw new RuntimeException("添加课程教师关联失败: " + e.getMessage(), e);
        }
        
        // 如果有关联项目，添加课程与项目关联关系
        if (projectIds != null && !projectIds.isEmpty()) {
            try {
                // 过滤无效的项目ID
                List<Long> validProjectIds = projectIds.stream()
                        .filter(id -> id != null && id > 0)
                        .collect(Collectors.toList());
                
                if (!validProjectIds.isEmpty()) {
                    courseMapper.insertCourseProjectRef(courseId, validProjectIds);
                }
            } catch (Exception e) {
                throw new RuntimeException("添加课程项目关联失败: " + e.getMessage(), e);
            }
        }
        
        return courseId;
    }
    
    /**
     * 更新课程信息
     * 
     * @param course 课程信息
     * @param projectIds 关联的项目ID列表
     * @return 是否更新成功
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean updateCourse(Course course, List<Long> projectIds) {
        if (course == null || course.getCourseId() == null) {
            throw new IllegalArgumentException("课程信息不能为空");
        }
        
        // 确保课程名称不为空
        if (course.getCourseName() != null && course.getCourseName().trim().isEmpty()) {
            throw new IllegalArgumentException("课程名称不能为空");
        }
        
        try {
            // 更新课程基本信息
            courseMapper.updateCourse(course);
            
            // 如果有关联项目，先删除旧的关联关系，再添加新的
            if (projectIds != null && !projectIds.isEmpty()) {
                // 过滤无效的项目ID
                List<Long> validProjectIds = projectIds.stream()
                        .filter(id -> id != null && id > 0)
                        .collect(Collectors.toList());
                
                if (!validProjectIds.isEmpty()) {
                    // 删除旧的关联关系
                    courseMapper.deleteCourseProjectRef(course.getCourseId());
                    // 添加新的关联关系
                    courseMapper.insertCourseProjectRef(course.getCourseId(), validProjectIds);
                }
            }
            
            return true;
        } catch (Exception e) {
            throw new RuntimeException("更新课程失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 删除课程
     * 
     * @param courseId 课程ID
     * @return 是否删除成功
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean deleteCourse(Long courseId) {
        if (courseId == null) {
            throw new IllegalArgumentException("课程ID不能为空");
        }
        
        try {
            // 首先删除课程与项目的关联关系
            courseMapper.deleteCourseProjectRef(courseId);
            
            // 删除课程与教师的关联关系
            courseMapper.deleteCourseTeacherRef(courseId);
            
            // 最后删除课程本身
            int result = courseMapper.deleteCourse(courseId);
            
            return result > 0;
        } catch (Exception e) {
            throw new RuntimeException("删除课程失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 检查课程与教师的关联关系是否已存在
     * 
     * @param courseId 课程ID
     * @param userId 用户ID
     * @return 关联关系是否存在
     */
    @Override
    public boolean checkCourseTeacherRefExists(Long courseId, Long userId) {
        if (courseId == null || userId == null) {
            throw new IllegalArgumentException("课程ID和用户ID不能为空");
        }
        
        Integer count = courseMapper.checkCourseTeacherRefExists(courseId, userId);
        return count != null && count > 0;
    }
    
    /**
     * 添加课程与教师的关联关系
     * 
     * @param courseId 课程ID
     * @param userId 用户ID
     * @return 是否添加成功
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean insertCourseTeacherRef(Long courseId, Long userId) {
        if (courseId == null || userId == null) {
            throw new IllegalArgumentException("课程ID和用户ID不能为空");
        }
        
        try {
            // 先检查是否已存在关联关系
            if (checkCourseTeacherRefExists(courseId, userId)) {
                return true; // 已存在，直接返回成功
            }
            
            int result = courseMapper.insertCourseTeacherRef(courseId, userId);
            return result > 0;
        } catch (Exception e) {
            throw new RuntimeException("添加课程教师关联失败: " + e.getMessage(), e);
        }
    }
}
